YES 0.53 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/FiniteMap.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ BR

mainModule FiniteMap
  ((lookupFM :: FiniteMap () a  ->  ()  ->  Maybe a) :: FiniteMap () a  ->  ()  ->  Maybe a)

module FiniteMap where
  import qualified Maybe
import qualified Prelude

  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a


  instance (Eq a, Eq b) => Eq (FiniteMap a b) where 

  lookupFM :: Ord b => FiniteMap b a  ->  b  ->  Maybe a
lookupFM EmptyFM key Nothing
lookupFM (Branch key elt _ fm_l fm_rkey_to_find 
 | key_to_find < key = 
lookupFM fm_l key_to_find
 | key_to_find > key = 
lookupFM fm_r key_to_find
 | otherwise = 
Just elt


module Maybe where
  import qualified FiniteMap
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ BR
HASKELL
      ↳ COR

mainModule FiniteMap
  ((lookupFM :: FiniteMap () a  ->  ()  ->  Maybe a) :: FiniteMap () a  ->  ()  ->  Maybe a)

module FiniteMap where
  import qualified Maybe
import qualified Prelude

  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a


  instance (Eq a, Eq b) => Eq (FiniteMap a b) where 

  lookupFM :: Ord a => FiniteMap a b  ->  a  ->  Maybe b
lookupFM EmptyFM key Nothing
lookupFM (Branch key elt vw fm_l fm_rkey_to_find 
 | key_to_find < key = 
lookupFM fm_l key_to_find
 | key_to_find > key = 
lookupFM fm_r key_to_find
 | otherwise = 
Just elt


module Maybe where
  import qualified FiniteMap
import qualified Prelude



Cond Reductions:
The following Function with conditions
lookupFM EmptyFM key = Nothing
lookupFM (Branch key elt vw fm_l fm_rkey_to_find
 | key_to_find < key
 = lookupFM fm_l key_to_find
 | key_to_find > key
 = lookupFM fm_r key_to_find
 | otherwise
 = Just elt

is transformed to
lookupFM EmptyFM key = lookupFM4 EmptyFM key
lookupFM (Branch key elt vw fm_l fm_rkey_to_find = lookupFM3 (Branch key elt vw fm_l fm_rkey_to_find

lookupFM2 key elt vw fm_l fm_r key_to_find True = lookupFM fm_l key_to_find
lookupFM2 key elt vw fm_l fm_r key_to_find False = lookupFM1 key elt vw fm_l fm_r key_to_find (key_to_find > key)

lookupFM0 key elt vw fm_l fm_r key_to_find True = Just elt

lookupFM1 key elt vw fm_l fm_r key_to_find True = lookupFM fm_r key_to_find
lookupFM1 key elt vw fm_l fm_r key_to_find False = lookupFM0 key elt vw fm_l fm_r key_to_find otherwise

lookupFM3 (Branch key elt vw fm_l fm_rkey_to_find = lookupFM2 key elt vw fm_l fm_r key_to_find (key_to_find < key)

lookupFM4 EmptyFM key = Nothing
lookupFM4 wv ww = lookupFM3 wv ww

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ BR
    ↳ HASKELL
      ↳ COR
HASKELL
          ↳ Narrow

mainModule FiniteMap
  (lookupFM :: FiniteMap () a  ->  ()  ->  Maybe a)

module FiniteMap where
  import qualified Maybe
import qualified Prelude

  data FiniteMap a b = EmptyFM  | Branch a b Int (FiniteMap a b) (FiniteMap a b


  instance (Eq a, Eq b) => Eq (FiniteMap b a) where 

  lookupFM :: Ord a => FiniteMap a b  ->  a  ->  Maybe b
lookupFM EmptyFM key lookupFM4 EmptyFM key
lookupFM (Branch key elt vw fm_l fm_rkey_to_find lookupFM3 (Branch key elt vw fm_l fm_r) key_to_find

  
lookupFM0 key elt vw fm_l fm_r key_to_find True Just elt

  
lookupFM1 key elt vw fm_l fm_r key_to_find True lookupFM fm_r key_to_find
lookupFM1 key elt vw fm_l fm_r key_to_find False lookupFM0 key elt vw fm_l fm_r key_to_find otherwise

  
lookupFM2 key elt vw fm_l fm_r key_to_find True lookupFM fm_l key_to_find
lookupFM2 key elt vw fm_l fm_r key_to_find False lookupFM1 key elt vw fm_l fm_r key_to_find (key_to_find > key)

  
lookupFM3 (Branch key elt vw fm_l fm_rkey_to_find lookupFM2 key elt vw fm_l fm_r key_to_find (key_to_find < key)

  
lookupFM4 EmptyFM key Nothing
lookupFM4 wv ww lookupFM3 wv ww


module Maybe where
  import qualified FiniteMap
import qualified Prelude



Haskell To QDPs